home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / amiga / plotting / gnuplot3.lzh / gnuplot / term / dumb.trm < prev    next >
Text File  |  1991-09-08  |  6KB  |  303 lines
  1. /* GNUPLOT - dumb.trm */
  2. /*
  3.  * Copyright (C) 1991
  4.  *
  5.  * Permission to use, copy, and distribute this software and its
  6.  * documentation for any purpose with or without fee is hereby granted,
  7.  * provided that the above copyright notice appear in all copies and
  8.  * that both that copyright notice and this permission notice appear
  9.  * in supporting documentation.
  10.  *
  11.  * Permission to modify the software is granted, but not the right to
  12.  * distribute the modified code.  Modifications are to be distributed
  13.  * as patches to released version.
  14.  *
  15.  * This software  is provided "as is" without express or implied warranty.
  16.  *
  17.  * This file is included by ../term.c.
  18.  *
  19.  * This terminal driver supports:
  20.  *   DUMB terminals
  21.  *
  22.  * AUTHORS
  23.  *   Francois Pinard, 91-04-03
  24.  *           INTERNET: pinard@iro.umontreal.ca
  25.  *
  26.  * send your comments or suggestions to (pixar!info-gnuplot@sun.com).
  27.  *
  28.  */
  29.  
  30. #define DUMB_AXIS_CONST '\1'
  31. #define DUMB_BORDER_CONST '\2'
  32.  
  33. #define DUMB_XMAX 79
  34. #define DUMB_YMAX 24
  35.  
  36. static char *dumb_matrix = NULL;      /* matrix of characters */
  37. static char *dumb_priority = NULL;    /* matrix of priority at each position */
  38. static char dumb_pen;                 /* current character used to draw */
  39. static int dumb_x;                    /* current X position */
  40. static int dumb_y;                    /* current Y position */
  41. static int dumb_xmax = DUMB_XMAX;
  42. static int dumb_ymax = DUMB_YMAX;
  43.  
  44. #define DUMB_PIXEL(x,y) dumb_matrix[dumb_xmax*(y)+(x)]
  45.  
  46.  
  47. dumb_set_pixel(x,y,v,p)
  48. int x,y,v,p;
  49. {
  50.   if (p > dumb_priority[dumb_xmax*y+x])
  51.     {
  52.       dumb_matrix[dumb_xmax*y+x] = v;
  53.       dumb_priority[dumb_xmax*y+x] = p;
  54.     }
  55. }
  56.  
  57.  
  58. DUMB_options()
  59. {
  60.   int x,y;
  61.   struct value a;
  62.   extern struct value *const_express();
  63.   extern double real();
  64.  
  65.   if (!END_OF_COMMAND) {
  66.     x = (int) real(const_express(&a));
  67.     if (!END_OF_COMMAND) {
  68.       y = (int) real(const_express(&a));
  69.       dumb_xmax = term_tbl[term].xmax = x;
  70.       dumb_ymax = term_tbl[term].ymax = y;
  71.     }
  72.   }
  73.  
  74.   sprintf(term_options, "%d %d",dumb_xmax,dumb_ymax);
  75. }
  76.  
  77.  
  78. DUMB_init()
  79. {
  80.   if (dumb_matrix)
  81.     free(dumb_matrix);
  82.  
  83.   dumb_matrix = alloc (dumb_xmax * dumb_ymax * 2, "dumb terminal");
  84.  
  85.   dumb_priority = dumb_matrix + dumb_xmax * dumb_ymax;
  86. }
  87.  
  88.  
  89. char *
  90. DUMB_str_state()
  91. {
  92.    static char str[80];
  93.  
  94.    sprintf( str, "%d %d", dumb_xmax, dumb_ymax );
  95.  
  96.    return str;
  97. }
  98.  
  99.  
  100. DUMB_graphics ()
  101. {
  102.   int i;
  103.   char *pm = dumb_matrix, *pp = dumb_priority;
  104.  
  105.   for ( i = dumb_xmax * dumb_ymax; i > 0; i-- ) {
  106.     *pm++ = ' ';
  107.     *pp++ = 0;
  108.   }
  109. }
  110.  
  111.  
  112. DUMB_text ()
  113. {
  114.   int x, y, l;
  115.  
  116.   putc ('\f', outfile);
  117.   for (y = dumb_ymax - 1; y >= 0; y--)
  118.     {
  119.       for (l = dumb_xmax; l > 0 && DUMB_PIXEL (l - 1, y) == ' '; l--)
  120.        ;
  121.       for (x = 0; x < l; x++)
  122.        putc (DUMB_PIXEL (x, y), outfile);
  123.       if (y > 0)
  124.        putc ('\n', outfile);
  125.     }
  126.   fflush (outfile);
  127. }
  128.  
  129.  
  130. DUMB_reset()
  131. {
  132.   free (dumb_matrix);
  133.   dumb_matrix = NULL;
  134. }
  135.  
  136.  
  137. DUMB_linetype(linetype)
  138. int linetype;
  139. {
  140.   static char pen_type[7] = {'*', '#', '$', '%', '@', '&', '='};
  141.  
  142.   if (linetype == -2)
  143.     dumb_pen = DUMB_BORDER_CONST;
  144.   else if (linetype == -1)
  145.     dumb_pen = DUMB_AXIS_CONST;
  146.   else
  147.     {
  148.       linetype = linetype % 7;
  149.       dumb_pen = pen_type[linetype];
  150.     }
  151. }
  152.  
  153.  
  154. DUMB_move(x, y)
  155. int x, y;
  156. {
  157.   dumb_x = x;
  158.   dumb_y = y;
  159. }
  160.  
  161.  
  162. DUMB_point(x,y,point)
  163. int x,y,point;
  164. {
  165.   dumb_set_pixel (x, y, point == -1 ? '.' : point % 26 + 'A', 4);
  166. }
  167.  
  168.  
  169. DUMB_vector(x,y)
  170. int x,y;
  171. {
  172.   char pen, pen1;
  173.   int priority;
  174.   int delta;
  175.  
  176.   if (abs (y - dumb_y) > abs (x - dumb_x))
  177.     {
  178.       switch (dumb_pen)
  179.        {
  180.        case DUMB_AXIS_CONST:
  181.          pen = ':';
  182.          pen1 = '+';
  183.          priority = 1;
  184.          break;
  185.  
  186.        case DUMB_BORDER_CONST:
  187.          pen = '|';
  188.          pen1 = '+';
  189.          priority = 2;
  190.          break;
  191.  
  192.        default:
  193.          pen = dumb_pen;
  194.          pen1 = dumb_pen;
  195.          priority = 3;
  196.          break;
  197.        }
  198.       dumb_set_pixel (dumb_x, dumb_y, pen1, priority);
  199.       for (delta = 1; delta < abs (y - dumb_y); delta++)
  200.        dumb_set_pixel (dumb_x
  201.                        + (int) ((double) (x - dumb_x) * delta / abs(y - dumb_y)
  202.                                 + 0.5),
  203.                        dumb_y + delta * sign (y - dumb_y),
  204.                        pen, priority);
  205.       dumb_set_pixel (x, y, pen1, priority);
  206.     }
  207.   else if (abs (x - dumb_x) > abs (y - dumb_y))
  208.     {
  209.       switch (dumb_pen)
  210.        {
  211.        case DUMB_AXIS_CONST:
  212.          pen = '.';
  213.          pen1 = '+';
  214.          priority = 1;
  215.          break;
  216.  
  217.        case DUMB_BORDER_CONST:
  218.          pen = '-';
  219.          pen1 = '+';
  220.          priority = 2;
  221.          break;
  222.  
  223.        default:
  224.          pen = dumb_pen;
  225.          pen1 = dumb_pen;
  226.          priority = 3;
  227.          break;
  228.        }
  229.       dumb_set_pixel (dumb_x, dumb_y, pen1, priority);
  230.       for (delta = 1; delta < abs (x - dumb_x); delta++)
  231.        dumb_set_pixel (dumb_x + delta * sign (x - dumb_x),
  232.                        dumb_y +
  233.                        (int) ((double) (y - dumb_y) * delta / abs(x - dumb_x)
  234.                               + 0.5),
  235.                        pen, priority);
  236.       dumb_set_pixel (x, y, pen1, priority);
  237.     }
  238.   else
  239.     {
  240.       switch (dumb_pen)
  241.        {
  242.        case DUMB_AXIS_CONST:    /* zero length axis */
  243.          pen = '+';
  244.          priority = 1;
  245.          break;
  246.  
  247.        case DUMB_BORDER_CONST:    /* zero length border */
  248.          pen = '+';
  249.          priority = 2;
  250.          break;
  251.  
  252.        default:
  253.          pen = dumb_pen;
  254.          priority = 3;
  255.          break;
  256.        }
  257.       for (delta = 0; delta <= abs (x - dumb_x); delta++)
  258.     dumb_set_pixel (dumb_x + delta * sign (x - dumb_x),
  259.             dumb_y + delta * sign (y - dumb_y),
  260.             pen, priority);
  261.     }
  262.   dumb_x = x;
  263.   dumb_y = y;
  264. }
  265.  
  266.  
  267. DUMB_put_text(x,y,str)
  268. int x, y;
  269. char *str;
  270. {
  271.   int length;
  272.   int delta;
  273.  
  274.   length = strlen(str);
  275.   if (x + length > dumb_xmax)
  276.     x = max (0, dumb_xmax - length);
  277.  
  278.   for (; x < dumb_xmax && *str; x++, str++)
  279.     dumb_set_pixel (x, y, *str, 5);
  280. }
  281.  
  282.  
  283. DUMB_arrow (sx,sy,ex,ey)
  284. int sx,sy,ex,ey;
  285. {
  286.   char saved_pen;
  287.   char saved_x;
  288.   char saved_y;
  289.  
  290.   saved_pen = dumb_pen;
  291.   saved_x = dumb_x;
  292.   saved_y = dumb_y;
  293.  
  294.   dumb_pen = '>';
  295.   dumb_x = sx;
  296.   dumb_y = sy;
  297.   DUMB_vector (ex,ey);
  298.  
  299.   dumb_pen = saved_pen;
  300.   dumb_x = saved_x;
  301.   dumb_y = saved_y;
  302. }
  303.